//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Chatbot service.
///
/// The AWS Chatbot API Reference provides descriptions, API request parameters, and the XML response for each of the AWS Chatbot API actions. AWS Chatbot APIs are currently available in the following Regions:   US East (Ohio) - us-east-2    US West (Oregon) - us-west-2    Asia Pacific (Singapore) - ap-southeast-1    Europe (Ireland) - eu-west-1    The AWS Chatbot console can only be used in US East (Ohio). Your configuration data however, is stored in each of the relevant available Regions.  Your AWS CloudTrail events are logged in whatever Region you call from, not US East (N. Virginia) by default.
public struct Chatbot: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Chatbot client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Chatbot",
            serviceIdentifier: "chatbot",
            serviceProtocol: .restjson,
            apiVersion: "2017-10-11",
            endpoint: endpoint,
            errorType: ChatbotErrorType.self,
            xmlNamespace: "http://wheatley.amazonaws.com/orchestration/2017-10-11/",
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Links a resource (for example, a custom action) to a channel configuration.
    @Sendable
    @inlinable
    public func associateToConfiguration(_ input: AssociateToConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateToConfigurationResult {
        try await self.client.execute(
            operation: "AssociateToConfiguration", 
            path: "/associate-to-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Links a resource (for example, a custom action) to a channel configuration.
    ///
    /// Parameters:
    ///   - chatConfiguration: The channel configuration to associate with the resource.
    ///   - resource: The resource Amazon Resource Name (ARN) to link.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateToConfiguration(
        chatConfiguration: String,
        resource: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateToConfigurationResult {
        let input = AssociateToConfigurationRequest(
            chatConfiguration: chatConfiguration, 
            resource: resource
        )
        return try await self.associateToConfiguration(input, logger: logger)
    }

    /// Creates an AWS Chatbot configuration for Amazon Chime.
    @Sendable
    @inlinable
    public func createChimeWebhookConfiguration(_ input: CreateChimeWebhookConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateChimeWebhookConfigurationResult {
        try await self.client.execute(
            operation: "CreateChimeWebhookConfiguration", 
            path: "/create-chime-webhook-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an AWS Chatbot configuration for Amazon Chime.
    ///
    /// Parameters:
    ///   - configurationName: The name of the configuration.
    ///   - iamRoleArn: A user-defined role that AWS Chatbot assumes. This is not the service-linked role. For more information, see IAM policies for AWS Chatbot in the  AWS Chatbot Administrator Guide.
    ///   - loggingLevel: Logging levels include ERROR, INFO, or NONE.
    ///   - snsTopicArns: The Amazon Resource Names (ARNs) of the SNS topics that deliver notifications to AWS Chatbot.
    ///   - tags: A map of tags assigned to a resource. A tag is a string-to-string map of key-value pairs.
    ///   - webhookDescription: A description of the webhook. We recommend using the convention RoomName/WebhookName. For more information, see Tutorial: Get started with Amazon Chime in the  AWS Chatbot Administrator Guide.
    ///   - webhookUrl: The URL for the Amazon Chime webhook.
    ///   - logger: Logger use during operation
    @inlinable
    public func createChimeWebhookConfiguration(
        configurationName: String,
        iamRoleArn: String,
        loggingLevel: String? = nil,
        snsTopicArns: [String],
        tags: [Tag]? = nil,
        webhookDescription: String,
        webhookUrl: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateChimeWebhookConfigurationResult {
        let input = CreateChimeWebhookConfigurationRequest(
            configurationName: configurationName, 
            iamRoleArn: iamRoleArn, 
            loggingLevel: loggingLevel, 
            snsTopicArns: snsTopicArns, 
            tags: tags, 
            webhookDescription: webhookDescription, 
            webhookUrl: webhookUrl
        )
        return try await self.createChimeWebhookConfiguration(input, logger: logger)
    }

    /// Creates a custom action that can be invoked as an alias or as a button on a notification.
    @Sendable
    @inlinable
    public func createCustomAction(_ input: CreateCustomActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCustomActionResult {
        try await self.client.execute(
            operation: "CreateCustomAction", 
            path: "/create-custom-action", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a custom action that can be invoked as an alias or as a button on a notification.
    ///
    /// Parameters:
    ///   - actionName: The name of the custom action. This name is included in the Amazon Resource Name (ARN).
    ///   - aliasName: The name used to invoke this action in a chat channel. For example, @aws run my-alias.
    ///   - attachments: Defines when this custom action button should be attached to a notification.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request. If you do not specify a client token, one is automatically generated by the SDK.
    ///   - definition: The definition of the command to run when invoked as an alias or as an action button.
    ///   - tags: A map of tags assigned to a resource. A tag is a string-to-string map of key-value pairs.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCustomAction(
        actionName: String,
        aliasName: String? = nil,
        attachments: [CustomActionAttachment]? = nil,
        clientToken: String? = CreateCustomActionRequest.idempotencyToken(),
        definition: CustomActionDefinition,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCustomActionResult {
        let input = CreateCustomActionRequest(
            actionName: actionName, 
            aliasName: aliasName, 
            attachments: attachments, 
            clientToken: clientToken, 
            definition: definition, 
            tags: tags
        )
        return try await self.createCustomAction(input, logger: logger)
    }

    /// Creates an AWS Chatbot configuration for Microsoft Teams.
    @Sendable
    @inlinable
    public func createMicrosoftTeamsChannelConfiguration(_ input: CreateTeamsChannelConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTeamsChannelConfigurationResult {
        try await self.client.execute(
            operation: "CreateMicrosoftTeamsChannelConfiguration", 
            path: "/create-ms-teams-channel-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an AWS Chatbot configuration for Microsoft Teams.
    ///
    /// Parameters:
    ///   - channelId: The ID of the Microsoft Teams channel.
    ///   - channelName: The name of the Microsoft Teams channel.
    ///   - configurationName: The name of the configuration.
    ///   - guardrailPolicyArns: The list of IAM policy ARNs that are applied as channel guardrails. The AWS managed AdministratorAccess policy is applied by default if this is not set.
    ///   - iamRoleArn: A user-defined role that AWS Chatbot assumes. This is not the service-linked role. For more information, see IAM policies for AWS Chatbot in the  AWS Chatbot Administrator Guide.
    ///   - loggingLevel: Logging levels include ERROR, INFO, or NONE.
    ///   - snsTopicArns: The Amazon Resource Names (ARNs) of the SNS topics that deliver notifications to AWS Chatbot.
    ///   - tags: A map of tags assigned to a resource. A tag is a string-to-string map of key-value pairs.
    ///   - teamId:  The ID of the Microsoft Teams authorized with AWS Chatbot. To get the team ID, you must perform the initial authorization flow with Microsoft Teams in the AWS Chatbot console. Then you can copy and paste the team ID from the console. For more information, see Step 1: Configure a Microsoft Teams client in the  AWS Chatbot Administrator Guide.
    ///   - teamName: The name of the Microsoft Teams Team.
    ///   - tenantId: The ID of the Microsoft Teams tenant.
    ///   - userAuthorizationRequired: Enables use of a user role requirement in your chat configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMicrosoftTeamsChannelConfiguration(
        channelId: String,
        channelName: String? = nil,
        configurationName: String,
        guardrailPolicyArns: [String]? = nil,
        iamRoleArn: String,
        loggingLevel: String? = nil,
        snsTopicArns: [String]? = nil,
        tags: [Tag]? = nil,
        teamId: String,
        teamName: String? = nil,
        tenantId: String,
        userAuthorizationRequired: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTeamsChannelConfigurationResult {
        let input = CreateTeamsChannelConfigurationRequest(
            channelId: channelId, 
            channelName: channelName, 
            configurationName: configurationName, 
            guardrailPolicyArns: guardrailPolicyArns, 
            iamRoleArn: iamRoleArn, 
            loggingLevel: loggingLevel, 
            snsTopicArns: snsTopicArns, 
            tags: tags, 
            teamId: teamId, 
            teamName: teamName, 
            tenantId: tenantId, 
            userAuthorizationRequired: userAuthorizationRequired
        )
        return try await self.createMicrosoftTeamsChannelConfiguration(input, logger: logger)
    }

    /// Creates an AWS Chatbot confugration for Slack.
    @Sendable
    @inlinable
    public func createSlackChannelConfiguration(_ input: CreateSlackChannelConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSlackChannelConfigurationResult {
        try await self.client.execute(
            operation: "CreateSlackChannelConfiguration", 
            path: "/create-slack-channel-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an AWS Chatbot confugration for Slack.
    ///
    /// Parameters:
    ///   - configurationName: The name of the configuration.
    ///   - guardrailPolicyArns: The list of IAM policy ARNs that are applied as channel guardrails. The AWS managed AdministratorAccess policy is applied by default if this is not set.
    ///   - iamRoleArn: A user-defined role that AWS Chatbot assumes. This is not the service-linked role. For more information, see IAM policies for AWS Chatbot in the  AWS Chatbot Administrator Guide.
    ///   - loggingLevel: Logging levels include ERROR, INFO, or NONE.
    ///   - slackChannelId: The ID of the Slack channel. To get this ID, open Slack, right click on the channel name in the left pane, then choose Copy Link. The channel ID is the 9-character string at the end of the URL. For example, ABCBBLZZZ.
    ///   - slackChannelName: The name of the Slack channel.
    ///   - slackTeamId: The ID of the Slack workspace authorized with AWS Chatbot.
    ///   - snsTopicArns: The Amazon Resource Names (ARNs) of the SNS topics that deliver notifications to AWS Chatbot.
    ///   - tags: A map of tags assigned to a resource. A tag is a string-to-string map of key-value pairs.
    ///   - userAuthorizationRequired: Enables use of a user role requirement in your chat configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSlackChannelConfiguration(
        configurationName: String,
        guardrailPolicyArns: [String]? = nil,
        iamRoleArn: String,
        loggingLevel: String? = nil,
        slackChannelId: String,
        slackChannelName: String? = nil,
        slackTeamId: String,
        snsTopicArns: [String]? = nil,
        tags: [Tag]? = nil,
        userAuthorizationRequired: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSlackChannelConfigurationResult {
        let input = CreateSlackChannelConfigurationRequest(
            configurationName: configurationName, 
            guardrailPolicyArns: guardrailPolicyArns, 
            iamRoleArn: iamRoleArn, 
            loggingLevel: loggingLevel, 
            slackChannelId: slackChannelId, 
            slackChannelName: slackChannelName, 
            slackTeamId: slackTeamId, 
            snsTopicArns: snsTopicArns, 
            tags: tags, 
            userAuthorizationRequired: userAuthorizationRequired
        )
        return try await self.createSlackChannelConfiguration(input, logger: logger)
    }

    /// Deletes a Amazon Chime webhook configuration for AWS Chatbot.
    @Sendable
    @inlinable
    public func deleteChimeWebhookConfiguration(_ input: DeleteChimeWebhookConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteChimeWebhookConfigurationResult {
        try await self.client.execute(
            operation: "DeleteChimeWebhookConfiguration", 
            path: "/delete-chime-webhook-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a Amazon Chime webhook configuration for AWS Chatbot.
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the ChimeWebhookConfiguration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteChimeWebhookConfiguration(
        chatConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteChimeWebhookConfigurationResult {
        let input = DeleteChimeWebhookConfigurationRequest(
            chatConfigurationArn: chatConfigurationArn
        )
        return try await self.deleteChimeWebhookConfiguration(input, logger: logger)
    }

    /// Deletes a custom action.
    @Sendable
    @inlinable
    public func deleteCustomAction(_ input: DeleteCustomActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCustomActionResult {
        try await self.client.execute(
            operation: "DeleteCustomAction", 
            path: "/delete-custom-action", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a custom action.
    ///
    /// Parameters:
    ///   - customActionArn: The fully defined ARN of the custom action.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCustomAction(
        customActionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCustomActionResult {
        let input = DeleteCustomActionRequest(
            customActionArn: customActionArn
        )
        return try await self.deleteCustomAction(input, logger: logger)
    }

    /// Deletes a Microsoft Teams channel configuration for AWS Chatbot
    @Sendable
    @inlinable
    public func deleteMicrosoftTeamsChannelConfiguration(_ input: DeleteTeamsChannelConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTeamsChannelConfigurationResult {
        try await self.client.execute(
            operation: "DeleteMicrosoftTeamsChannelConfiguration", 
            path: "/delete-ms-teams-channel-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a Microsoft Teams channel configuration for AWS Chatbot
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the MicrosoftTeamsChannelConfiguration associated with the user identity to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMicrosoftTeamsChannelConfiguration(
        chatConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTeamsChannelConfigurationResult {
        let input = DeleteTeamsChannelConfigurationRequest(
            chatConfigurationArn: chatConfigurationArn
        )
        return try await self.deleteMicrosoftTeamsChannelConfiguration(input, logger: logger)
    }

    /// Deletes the Microsoft Teams team authorization allowing for channels to be configured in that Microsoft Teams team. Note that the Microsoft Teams team must have no channels configured to remove it.
    @Sendable
    @inlinable
    public func deleteMicrosoftTeamsConfiguredTeam(_ input: DeleteTeamsConfiguredTeamRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTeamsConfiguredTeamResult {
        try await self.client.execute(
            operation: "DeleteMicrosoftTeamsConfiguredTeam", 
            path: "/delete-ms-teams-configured-teams", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the Microsoft Teams team authorization allowing for channels to be configured in that Microsoft Teams team. Note that the Microsoft Teams team must have no channels configured to remove it.
    ///
    /// Parameters:
    ///   - teamId: The ID of the Microsoft Teams team authorized with AWS Chatbot. To get the team ID, you must perform the initial authorization flow with Microsoft Teams in the AWS Chatbot console. Then you can copy and paste the team ID from the console. For more information, see Step 1: Configure a Microsoft Teams client in the  AWS Chatbot Administrator Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMicrosoftTeamsConfiguredTeam(
        teamId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTeamsConfiguredTeamResult {
        let input = DeleteTeamsConfiguredTeamRequest(
            teamId: teamId
        )
        return try await self.deleteMicrosoftTeamsConfiguredTeam(input, logger: logger)
    }

    /// Identifes a user level permission for a channel configuration.
    @Sendable
    @inlinable
    public func deleteMicrosoftTeamsUserIdentity(_ input: DeleteMicrosoftTeamsUserIdentityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMicrosoftTeamsUserIdentityResult {
        try await self.client.execute(
            operation: "DeleteMicrosoftTeamsUserIdentity", 
            path: "/delete-ms-teams-user-identity", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Identifes a user level permission for a channel configuration.
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The ARN of the MicrosoftTeamsChannelConfiguration associated with the user identity to delete.
    ///   - userId: The Microsoft Teams user ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMicrosoftTeamsUserIdentity(
        chatConfigurationArn: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMicrosoftTeamsUserIdentityResult {
        let input = DeleteMicrosoftTeamsUserIdentityRequest(
            chatConfigurationArn: chatConfigurationArn, 
            userId: userId
        )
        return try await self.deleteMicrosoftTeamsUserIdentity(input, logger: logger)
    }

    /// Deletes a Slack channel configuration for AWS Chatbot
    @Sendable
    @inlinable
    public func deleteSlackChannelConfiguration(_ input: DeleteSlackChannelConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSlackChannelConfigurationResult {
        try await self.client.execute(
            operation: "DeleteSlackChannelConfiguration", 
            path: "/delete-slack-channel-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a Slack channel configuration for AWS Chatbot
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the SlackChannelConfiguration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSlackChannelConfiguration(
        chatConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSlackChannelConfigurationResult {
        let input = DeleteSlackChannelConfigurationRequest(
            chatConfigurationArn: chatConfigurationArn
        )
        return try await self.deleteSlackChannelConfiguration(input, logger: logger)
    }

    /// Deletes a user level permission for a Slack channel configuration.
    @Sendable
    @inlinable
    public func deleteSlackUserIdentity(_ input: DeleteSlackUserIdentityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSlackUserIdentityResult {
        try await self.client.execute(
            operation: "DeleteSlackUserIdentity", 
            path: "/delete-slack-user-identity", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a user level permission for a Slack channel configuration.
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The ARN of the SlackChannelConfiguration associated with the user identity to delete.
    ///   - slackTeamId: The ID of the Slack workspace authorized with AWS Chatbot.
    ///   - slackUserId: The ID of the user in Slack
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSlackUserIdentity(
        chatConfigurationArn: String,
        slackTeamId: String,
        slackUserId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSlackUserIdentityResult {
        let input = DeleteSlackUserIdentityRequest(
            chatConfigurationArn: chatConfigurationArn, 
            slackTeamId: slackTeamId, 
            slackUserId: slackUserId
        )
        return try await self.deleteSlackUserIdentity(input, logger: logger)
    }

    /// Deletes the Slack workspace authorization that allows channels to be configured in that workspace. This requires all configured channels in the workspace to be deleted.
    @Sendable
    @inlinable
    public func deleteSlackWorkspaceAuthorization(_ input: DeleteSlackWorkspaceAuthorizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSlackWorkspaceAuthorizationResult {
        try await self.client.execute(
            operation: "DeleteSlackWorkspaceAuthorization", 
            path: "/delete-slack-workspace-authorization", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the Slack workspace authorization that allows channels to be configured in that workspace. This requires all configured channels in the workspace to be deleted.
    ///
    /// Parameters:
    ///   - slackTeamId: The ID of the Slack workspace authorized with AWS Chatbot.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSlackWorkspaceAuthorization(
        slackTeamId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSlackWorkspaceAuthorizationResult {
        let input = DeleteSlackWorkspaceAuthorizationRequest(
            slackTeamId: slackTeamId
        )
        return try await self.deleteSlackWorkspaceAuthorization(input, logger: logger)
    }

    /// Lists Amazon Chime webhook configurations optionally filtered by ChatConfigurationArn
    @Sendable
    @inlinable
    public func describeChimeWebhookConfigurations(_ input: DescribeChimeWebhookConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeChimeWebhookConfigurationsResult {
        try await self.client.execute(
            operation: "DescribeChimeWebhookConfigurations", 
            path: "/describe-chime-webhook-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists Amazon Chime webhook configurations optionally filtered by ChatConfigurationArn
    ///
    /// Parameters:
    ///   - chatConfigurationArn: An optional Amazon Resource Name (ARN) of a ChimeWebhookConfiguration to describe.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken: An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeChimeWebhookConfigurations(
        chatConfigurationArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeChimeWebhookConfigurationsResult {
        let input = DescribeChimeWebhookConfigurationsRequest(
            chatConfigurationArn: chatConfigurationArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeChimeWebhookConfigurations(input, logger: logger)
    }

    /// Lists Slack channel configurations optionally filtered by ChatConfigurationArn
    @Sendable
    @inlinable
    public func describeSlackChannelConfigurations(_ input: DescribeSlackChannelConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeSlackChannelConfigurationsResult {
        try await self.client.execute(
            operation: "DescribeSlackChannelConfigurations", 
            path: "/describe-slack-channel-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists Slack channel configurations optionally filtered by ChatConfigurationArn
    ///
    /// Parameters:
    ///   - chatConfigurationArn: An optional Amazon Resource Name (ARN) of a SlackChannelConfiguration to describe.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken:  An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeSlackChannelConfigurations(
        chatConfigurationArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeSlackChannelConfigurationsResult {
        let input = DescribeSlackChannelConfigurationsRequest(
            chatConfigurationArn: chatConfigurationArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeSlackChannelConfigurations(input, logger: logger)
    }

    /// Lists all Slack user identities with a mapped role.
    @Sendable
    @inlinable
    public func describeSlackUserIdentities(_ input: DescribeSlackUserIdentitiesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeSlackUserIdentitiesResult {
        try await self.client.execute(
            operation: "DescribeSlackUserIdentities", 
            path: "/describe-slack-user-identities", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all Slack user identities with a mapped role.
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the SlackChannelConfiguration associated with the user identities to describe.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken:  An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeSlackUserIdentities(
        chatConfigurationArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeSlackUserIdentitiesResult {
        let input = DescribeSlackUserIdentitiesRequest(
            chatConfigurationArn: chatConfigurationArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeSlackUserIdentities(input, logger: logger)
    }

    /// List all authorized Slack workspaces connected to the AWS Account onboarded with AWS Chatbot.
    @Sendable
    @inlinable
    public func describeSlackWorkspaces(_ input: DescribeSlackWorkspacesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeSlackWorkspacesResult {
        try await self.client.execute(
            operation: "DescribeSlackWorkspaces", 
            path: "/describe-slack-workspaces", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all authorized Slack workspaces connected to the AWS Account onboarded with AWS Chatbot.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken:  An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeSlackWorkspaces(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeSlackWorkspacesResult {
        let input = DescribeSlackWorkspacesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeSlackWorkspaces(input, logger: logger)
    }

    /// Unlink a resource, for example a custom action, from a channel configuration.
    @Sendable
    @inlinable
    public func disassociateFromConfiguration(_ input: DisassociateFromConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateFromConfigurationResult {
        try await self.client.execute(
            operation: "DisassociateFromConfiguration", 
            path: "/disassociate-from-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Unlink a resource, for example a custom action, from a channel configuration.
    ///
    /// Parameters:
    ///   - chatConfiguration: The channel configuration the resource is being disassociated from.
    ///   - resource: The resource (for example, a custom action) Amazon Resource Name (ARN) to unlink.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateFromConfiguration(
        chatConfiguration: String,
        resource: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateFromConfigurationResult {
        let input = DisassociateFromConfigurationRequest(
            chatConfiguration: chatConfiguration, 
            resource: resource
        )
        return try await self.disassociateFromConfiguration(input, logger: logger)
    }

    /// Returns AWS Chatbot account preferences.
    @Sendable
    @inlinable
    public func getAccountPreferences(_ input: GetAccountPreferencesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccountPreferencesResult {
        try await self.client.execute(
            operation: "GetAccountPreferences", 
            path: "/get-account-preferences", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns AWS Chatbot account preferences.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccountPreferences(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccountPreferencesResult {
        let input = GetAccountPreferencesRequest(
        )
        return try await self.getAccountPreferences(input, logger: logger)
    }

    /// Returns a custom action.
    @Sendable
    @inlinable
    public func getCustomAction(_ input: GetCustomActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCustomActionResult {
        try await self.client.execute(
            operation: "GetCustomAction", 
            path: "/get-custom-action", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a custom action.
    ///
    /// Parameters:
    ///   - customActionArn: Returns the fully defined Amazon Resource Name (ARN) of the custom action.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCustomAction(
        customActionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCustomActionResult {
        let input = GetCustomActionRequest(
            customActionArn: customActionArn
        )
        return try await self.getCustomAction(input, logger: logger)
    }

    /// Returns a Microsoft Teams channel configuration in an AWS account.
    @Sendable
    @inlinable
    public func getMicrosoftTeamsChannelConfiguration(_ input: GetTeamsChannelConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTeamsChannelConfigurationResult {
        try await self.client.execute(
            operation: "GetMicrosoftTeamsChannelConfiguration", 
            path: "/get-ms-teams-channel-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a Microsoft Teams channel configuration in an AWS account.
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the MicrosoftTeamsChannelConfiguration to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMicrosoftTeamsChannelConfiguration(
        chatConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTeamsChannelConfigurationResult {
        let input = GetTeamsChannelConfigurationRequest(
            chatConfigurationArn: chatConfigurationArn
        )
        return try await self.getMicrosoftTeamsChannelConfiguration(input, logger: logger)
    }

    /// Lists resources associated with a channel configuration.
    @Sendable
    @inlinable
    public func listAssociations(_ input: ListAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssociationsResult {
        try await self.client.execute(
            operation: "ListAssociations", 
            path: "/list-associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists resources associated with a channel configuration.
    ///
    /// Parameters:
    ///   - chatConfiguration: The channel configuration to list associations for.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken: An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssociations(
        chatConfiguration: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssociationsResult {
        let input = ListAssociationsRequest(
            chatConfiguration: chatConfiguration, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAssociations(input, logger: logger)
    }

    /// Lists custom actions defined in this account.
    @Sendable
    @inlinable
    public func listCustomActions(_ input: ListCustomActionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCustomActionsResult {
        try await self.client.execute(
            operation: "ListCustomActions", 
            path: "/list-custom-actions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists custom actions defined in this account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken: An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCustomActions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCustomActionsResult {
        let input = ListCustomActionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCustomActions(input, logger: logger)
    }

    /// Lists all AWS Chatbot Microsoft Teams channel configurations in an AWS account.
    @Sendable
    @inlinable
    public func listMicrosoftTeamsChannelConfigurations(_ input: ListTeamsChannelConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTeamsChannelConfigurationsResult {
        try await self.client.execute(
            operation: "ListMicrosoftTeamsChannelConfigurations", 
            path: "/list-ms-teams-channel-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all AWS Chatbot Microsoft Teams channel configurations in an AWS account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken: An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - teamId:  The ID of the Microsoft Teams authorized with AWS Chatbot. To get the team ID, you must perform the initial authorization flow with Microsoft Teams in the AWS Chatbot console. Then you can copy and paste the team ID from the console. For more information, see Step 1: Configure a Microsoft Teams client in the  AWS Chatbot Administrator Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMicrosoftTeamsChannelConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        teamId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTeamsChannelConfigurationsResult {
        let input = ListTeamsChannelConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            teamId: teamId
        )
        return try await self.listMicrosoftTeamsChannelConfigurations(input, logger: logger)
    }

    /// Lists all authorized Microsoft Teams for an AWS Account
    @Sendable
    @inlinable
    public func listMicrosoftTeamsConfiguredTeams(_ input: ListMicrosoftTeamsConfiguredTeamsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMicrosoftTeamsConfiguredTeamsResult {
        try await self.client.execute(
            operation: "ListMicrosoftTeamsConfiguredTeams", 
            path: "/list-ms-teams-configured-teams", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all authorized Microsoft Teams for an AWS Account
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken: An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMicrosoftTeamsConfiguredTeams(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMicrosoftTeamsConfiguredTeamsResult {
        let input = ListMicrosoftTeamsConfiguredTeamsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMicrosoftTeamsConfiguredTeams(input, logger: logger)
    }

    /// A list all Microsoft Teams user identities with a mapped role.
    @Sendable
    @inlinable
    public func listMicrosoftTeamsUserIdentities(_ input: ListMicrosoftTeamsUserIdentitiesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMicrosoftTeamsUserIdentitiesResult {
        try await self.client.execute(
            operation: "ListMicrosoftTeamsUserIdentities", 
            path: "/list-ms-teams-user-identities", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A list all Microsoft Teams user identities with a mapped role.
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the MicrosoftTeamsChannelConfiguration associated with the user identities to list.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - nextToken: An optional token returned from a prior request. Use this token for pagination of results from this action. If this parameter is specified, the response includes only results beyond the token, up to the value specified by MaxResults.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMicrosoftTeamsUserIdentities(
        chatConfigurationArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMicrosoftTeamsUserIdentitiesResult {
        let input = ListMicrosoftTeamsUserIdentitiesRequest(
            chatConfigurationArn: chatConfigurationArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMicrosoftTeamsUserIdentities(input, logger: logger)
    }

    /// Lists all of the tags associated with the Amazon Resource Name (ARN) that you specify. The resource can be a user, server, or role.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/list-tags-for-resource", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all of the tags associated with the Amazon Resource Name (ARN) that you specify. The resource can be a user, server, or role.
    ///
    /// Parameters:
    ///   - resourceARN: The ARN of the resource to list tags for.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceARN: resourceARN
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Attaches a key-value pair to a resource, as identified by its Amazon Resource Name (ARN). Resources are users, servers, roles, and other entities.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tag-resource", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Attaches a key-value pair to a resource, as identified by its Amazon Resource Name (ARN). Resources are users, servers, roles, and other entities.
    ///
    /// Parameters:
    ///   - resourceARN: The ARN of the configuration.
    ///   - tags: A list of tags to apply to the configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceARN: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceARN: resourceARN, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Detaches a key-value pair from a resource, as identified by its Amazon Resource Name (ARN). Resources are users, servers, roles, and other entities.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/untag-resource", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Detaches a key-value pair from a resource, as identified by its Amazon Resource Name (ARN). Resources are users, servers, roles, and other entities.
    ///
    /// Parameters:
    ///   - resourceARN: The value of the resource that will have the tag removed. An Amazon Resource Name (ARN) is an identifier for a specific AWS resource, such as a server, user, or role.
    ///   - tagKeys: TagKeys are key-value pairs assigned to ARNs that can be used to group and search for resources by type. This metadata can be attached to resources for any purpose.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceARN: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceARN: resourceARN, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates AWS Chatbot account preferences.
    @Sendable
    @inlinable
    public func updateAccountPreferences(_ input: UpdateAccountPreferencesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAccountPreferencesResult {
        try await self.client.execute(
            operation: "UpdateAccountPreferences", 
            path: "/update-account-preferences", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates AWS Chatbot account preferences.
    ///
    /// Parameters:
    ///   - trainingDataCollectionEnabled: Turns on training data collection. This helps improve the AWS Chatbot experience by allowing AWS Chatbot to store and use your customer information, such as AWS Chatbot configurations, notifications, user inputs, AWS Chatbot generated responses, and interaction data. This data helps us to continuously improve and develop Artificial Intelligence (AI) technologies. Your data is not shared with any third parties and is protected using sophisticated controls to prevent unauthorized access and misuse. AWS Chatbot does not store or use interactions in chat channels with Amazon Q for training AI technologies for AWS Chatbot.
    ///   - userAuthorizationRequired: Enables use of a user role requirement in your chat configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAccountPreferences(
        trainingDataCollectionEnabled: Bool? = nil,
        userAuthorizationRequired: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAccountPreferencesResult {
        let input = UpdateAccountPreferencesRequest(
            trainingDataCollectionEnabled: trainingDataCollectionEnabled, 
            userAuthorizationRequired: userAuthorizationRequired
        )
        return try await self.updateAccountPreferences(input, logger: logger)
    }

    /// Updates a Amazon Chime webhook configuration.
    @Sendable
    @inlinable
    public func updateChimeWebhookConfiguration(_ input: UpdateChimeWebhookConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateChimeWebhookConfigurationResult {
        try await self.client.execute(
            operation: "UpdateChimeWebhookConfiguration", 
            path: "/update-chime-webhook-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a Amazon Chime webhook configuration.
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the ChimeWebhookConfiguration to update.
    ///   - iamRoleArn: A user-defined role that AWS Chatbot assumes. This is not the service-linked role. For more information, see IAM policies for AWS Chatbot in the  AWS Chatbot Administrator Guide.
    ///   - loggingLevel: Logging levels include ERROR, INFO, or NONE.
    ///   - snsTopicArns: The ARNs of the SNS topics that deliver notifications to AWS Chatbot.
    ///   - webhookDescription: A description of the webhook. We recommend using the convention RoomName/WebhookName. For more information, see Tutorial: Get started with Amazon Chime in the  AWS Chatbot Administrator Guide.
    ///   - webhookUrl: The URL for the Amazon Chime webhook.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateChimeWebhookConfiguration(
        chatConfigurationArn: String,
        iamRoleArn: String? = nil,
        loggingLevel: String? = nil,
        snsTopicArns: [String]? = nil,
        webhookDescription: String? = nil,
        webhookUrl: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateChimeWebhookConfigurationResult {
        let input = UpdateChimeWebhookConfigurationRequest(
            chatConfigurationArn: chatConfigurationArn, 
            iamRoleArn: iamRoleArn, 
            loggingLevel: loggingLevel, 
            snsTopicArns: snsTopicArns, 
            webhookDescription: webhookDescription, 
            webhookUrl: webhookUrl
        )
        return try await self.updateChimeWebhookConfiguration(input, logger: logger)
    }

    /// Updates a custom action.
    @Sendable
    @inlinable
    public func updateCustomAction(_ input: UpdateCustomActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCustomActionResult {
        try await self.client.execute(
            operation: "UpdateCustomAction", 
            path: "/update-custom-action", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a custom action.
    ///
    /// Parameters:
    ///   - aliasName: The name used to invoke this action in the chat channel. For example, @aws run my-alias.
    ///   - attachments: Defines when this custom action button should be attached to a notification.
    ///   - customActionArn: The fully defined Amazon Resource Name (ARN) of the custom action.
    ///   - definition: The definition of the command to run when invoked as an alias or as an action button.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCustomAction(
        aliasName: String? = nil,
        attachments: [CustomActionAttachment]? = nil,
        customActionArn: String,
        definition: CustomActionDefinition,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCustomActionResult {
        let input = UpdateCustomActionRequest(
            aliasName: aliasName, 
            attachments: attachments, 
            customActionArn: customActionArn, 
            definition: definition
        )
        return try await self.updateCustomAction(input, logger: logger)
    }

    /// Updates an Microsoft Teams channel configuration.
    @Sendable
    @inlinable
    public func updateMicrosoftTeamsChannelConfiguration(_ input: UpdateTeamsChannelConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTeamsChannelConfigurationResult {
        try await self.client.execute(
            operation: "UpdateMicrosoftTeamsChannelConfiguration", 
            path: "/update-ms-teams-channel-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an Microsoft Teams channel configuration.
    ///
    /// Parameters:
    ///   - channelId: The ID of the Microsoft Teams channel.
    ///   - channelName: The name of the Microsoft Teams channel.
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the TeamsChannelConfiguration to update.
    ///   - guardrailPolicyArns: The list of IAM policy ARNs that are applied as channel guardrails. The AWS managed AdministratorAccess policy is applied by default if this is not set.
    ///   - iamRoleArn: A user-defined role that AWS Chatbot assumes. This is not the service-linked role. For more information, see IAM policies for AWS Chatbot in the  AWS Chatbot Administrator Guide.
    ///   - loggingLevel: Logging levels include ERROR, INFO, or NONE.
    ///   - snsTopicArns: The Amazon Resource Names (ARNs) of the SNS topics that deliver notifications to AWS Chatbot.
    ///   - userAuthorizationRequired: Enables use of a user role requirement in your chat configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMicrosoftTeamsChannelConfiguration(
        channelId: String,
        channelName: String? = nil,
        chatConfigurationArn: String,
        guardrailPolicyArns: [String]? = nil,
        iamRoleArn: String? = nil,
        loggingLevel: String? = nil,
        snsTopicArns: [String]? = nil,
        userAuthorizationRequired: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTeamsChannelConfigurationResult {
        let input = UpdateTeamsChannelConfigurationRequest(
            channelId: channelId, 
            channelName: channelName, 
            chatConfigurationArn: chatConfigurationArn, 
            guardrailPolicyArns: guardrailPolicyArns, 
            iamRoleArn: iamRoleArn, 
            loggingLevel: loggingLevel, 
            snsTopicArns: snsTopicArns, 
            userAuthorizationRequired: userAuthorizationRequired
        )
        return try await self.updateMicrosoftTeamsChannelConfiguration(input, logger: logger)
    }

    /// Updates a Slack channel configuration.
    @Sendable
    @inlinable
    public func updateSlackChannelConfiguration(_ input: UpdateSlackChannelConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSlackChannelConfigurationResult {
        try await self.client.execute(
            operation: "UpdateSlackChannelConfiguration", 
            path: "/update-slack-channel-configuration", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a Slack channel configuration.
    ///
    /// Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the SlackChannelConfiguration to update.
    ///   - guardrailPolicyArns: The list of IAM policy ARNs that are applied as channel guardrails. The AWS managed AdministratorAccess policy is applied by default if this is not set.
    ///   - iamRoleArn: A user-defined role that AWS Chatbot assumes. This is not the service-linked role. For more information, see IAM policies for AWS Chatbot in the  AWS Chatbot Administrator Guide.
    ///   - loggingLevel: Logging levels include ERROR, INFO, or NONE.
    ///   - slackChannelId: The ID of the Slack channel. To get this ID, open Slack, right click on the channel name in the left pane, then choose Copy Link. The channel ID is the 9-character string at the end of the URL. For example, ABCBBLZZZ.
    ///   - slackChannelName: The name of the Slack channel.
    ///   - snsTopicArns: The Amazon Resource Names (ARNs) of the SNS topics that deliver notifications to AWS Chatbot.
    ///   - userAuthorizationRequired: Enables use of a user role requirement in your chat configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSlackChannelConfiguration(
        chatConfigurationArn: String,
        guardrailPolicyArns: [String]? = nil,
        iamRoleArn: String? = nil,
        loggingLevel: String? = nil,
        slackChannelId: String,
        slackChannelName: String? = nil,
        snsTopicArns: [String]? = nil,
        userAuthorizationRequired: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSlackChannelConfigurationResult {
        let input = UpdateSlackChannelConfigurationRequest(
            chatConfigurationArn: chatConfigurationArn, 
            guardrailPolicyArns: guardrailPolicyArns, 
            iamRoleArn: iamRoleArn, 
            loggingLevel: loggingLevel, 
            slackChannelId: slackChannelId, 
            slackChannelName: slackChannelName, 
            snsTopicArns: snsTopicArns, 
            userAuthorizationRequired: userAuthorizationRequired
        )
        return try await self.updateSlackChannelConfiguration(input, logger: logger)
    }
}

extension Chatbot {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Chatbot, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Chatbot {
    /// Return PaginatorSequence for operation ``describeChimeWebhookConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeChimeWebhookConfigurationsPaginator(
        _ input: DescribeChimeWebhookConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeChimeWebhookConfigurationsRequest, DescribeChimeWebhookConfigurationsResult> {
        return .init(
            input: input,
            command: self.describeChimeWebhookConfigurations,
            inputKey: \DescribeChimeWebhookConfigurationsRequest.nextToken,
            outputKey: \DescribeChimeWebhookConfigurationsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeChimeWebhookConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - chatConfigurationArn: An optional Amazon Resource Name (ARN) of a ChimeWebhookConfiguration to describe.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeChimeWebhookConfigurationsPaginator(
        chatConfigurationArn: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeChimeWebhookConfigurationsRequest, DescribeChimeWebhookConfigurationsResult> {
        let input = DescribeChimeWebhookConfigurationsRequest(
            chatConfigurationArn: chatConfigurationArn, 
            maxResults: maxResults
        )
        return self.describeChimeWebhookConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeSlackChannelConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSlackChannelConfigurationsPaginator(
        _ input: DescribeSlackChannelConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeSlackChannelConfigurationsRequest, DescribeSlackChannelConfigurationsResult> {
        return .init(
            input: input,
            command: self.describeSlackChannelConfigurations,
            inputKey: \DescribeSlackChannelConfigurationsRequest.nextToken,
            outputKey: \DescribeSlackChannelConfigurationsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeSlackChannelConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - chatConfigurationArn: An optional Amazon Resource Name (ARN) of a SlackChannelConfiguration to describe.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSlackChannelConfigurationsPaginator(
        chatConfigurationArn: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeSlackChannelConfigurationsRequest, DescribeSlackChannelConfigurationsResult> {
        let input = DescribeSlackChannelConfigurationsRequest(
            chatConfigurationArn: chatConfigurationArn, 
            maxResults: maxResults
        )
        return self.describeSlackChannelConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeSlackUserIdentities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSlackUserIdentitiesPaginator(
        _ input: DescribeSlackUserIdentitiesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeSlackUserIdentitiesRequest, DescribeSlackUserIdentitiesResult> {
        return .init(
            input: input,
            command: self.describeSlackUserIdentities,
            inputKey: \DescribeSlackUserIdentitiesRequest.nextToken,
            outputKey: \DescribeSlackUserIdentitiesResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeSlackUserIdentities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the SlackChannelConfiguration associated with the user identities to describe.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSlackUserIdentitiesPaginator(
        chatConfigurationArn: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeSlackUserIdentitiesRequest, DescribeSlackUserIdentitiesResult> {
        let input = DescribeSlackUserIdentitiesRequest(
            chatConfigurationArn: chatConfigurationArn, 
            maxResults: maxResults
        )
        return self.describeSlackUserIdentitiesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeSlackWorkspaces(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSlackWorkspacesPaginator(
        _ input: DescribeSlackWorkspacesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeSlackWorkspacesRequest, DescribeSlackWorkspacesResult> {
        return .init(
            input: input,
            command: self.describeSlackWorkspaces,
            inputKey: \DescribeSlackWorkspacesRequest.nextToken,
            outputKey: \DescribeSlackWorkspacesResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeSlackWorkspaces(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSlackWorkspacesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeSlackWorkspacesRequest, DescribeSlackWorkspacesResult> {
        let input = DescribeSlackWorkspacesRequest(
            maxResults: maxResults
        )
        return self.describeSlackWorkspacesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssociationsPaginator(
        _ input: ListAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssociationsRequest, ListAssociationsResult> {
        return .init(
            input: input,
            command: self.listAssociations,
            inputKey: \ListAssociationsRequest.nextToken,
            outputKey: \ListAssociationsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - chatConfiguration: The channel configuration to list associations for.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssociationsPaginator(
        chatConfiguration: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssociationsRequest, ListAssociationsResult> {
        let input = ListAssociationsRequest(
            chatConfiguration: chatConfiguration, 
            maxResults: maxResults
        )
        return self.listAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCustomActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomActionsPaginator(
        _ input: ListCustomActionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCustomActionsRequest, ListCustomActionsResult> {
        return .init(
            input: input,
            command: self.listCustomActions,
            inputKey: \ListCustomActionsRequest.nextToken,
            outputKey: \ListCustomActionsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCustomActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomActionsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCustomActionsRequest, ListCustomActionsResult> {
        let input = ListCustomActionsRequest(
            maxResults: maxResults
        )
        return self.listCustomActionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMicrosoftTeamsChannelConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMicrosoftTeamsChannelConfigurationsPaginator(
        _ input: ListTeamsChannelConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTeamsChannelConfigurationsRequest, ListTeamsChannelConfigurationsResult> {
        return .init(
            input: input,
            command: self.listMicrosoftTeamsChannelConfigurations,
            inputKey: \ListTeamsChannelConfigurationsRequest.nextToken,
            outputKey: \ListTeamsChannelConfigurationsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMicrosoftTeamsChannelConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - teamId:  The ID of the Microsoft Teams authorized with AWS Chatbot. To get the team ID, you must perform the initial authorization flow with Microsoft Teams in the AWS Chatbot console. Then you can copy and paste the team ID from the console. For more information, see Step 1: Configure a Microsoft Teams client in the  AWS Chatbot Administrator Guide.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMicrosoftTeamsChannelConfigurationsPaginator(
        maxResults: Int? = nil,
        teamId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTeamsChannelConfigurationsRequest, ListTeamsChannelConfigurationsResult> {
        let input = ListTeamsChannelConfigurationsRequest(
            maxResults: maxResults, 
            teamId: teamId
        )
        return self.listMicrosoftTeamsChannelConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMicrosoftTeamsConfiguredTeams(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMicrosoftTeamsConfiguredTeamsPaginator(
        _ input: ListMicrosoftTeamsConfiguredTeamsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMicrosoftTeamsConfiguredTeamsRequest, ListMicrosoftTeamsConfiguredTeamsResult> {
        return .init(
            input: input,
            command: self.listMicrosoftTeamsConfiguredTeams,
            inputKey: \ListMicrosoftTeamsConfiguredTeamsRequest.nextToken,
            outputKey: \ListMicrosoftTeamsConfiguredTeamsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMicrosoftTeamsConfiguredTeams(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMicrosoftTeamsConfiguredTeamsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMicrosoftTeamsConfiguredTeamsRequest, ListMicrosoftTeamsConfiguredTeamsResult> {
        let input = ListMicrosoftTeamsConfiguredTeamsRequest(
            maxResults: maxResults
        )
        return self.listMicrosoftTeamsConfiguredTeamsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMicrosoftTeamsUserIdentities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMicrosoftTeamsUserIdentitiesPaginator(
        _ input: ListMicrosoftTeamsUserIdentitiesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMicrosoftTeamsUserIdentitiesRequest, ListMicrosoftTeamsUserIdentitiesResult> {
        return .init(
            input: input,
            command: self.listMicrosoftTeamsUserIdentities,
            inputKey: \ListMicrosoftTeamsUserIdentitiesRequest.nextToken,
            outputKey: \ListMicrosoftTeamsUserIdentitiesResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMicrosoftTeamsUserIdentities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - chatConfigurationArn: The Amazon Resource Name (ARN) of the MicrosoftTeamsChannelConfiguration associated with the user identities to list.
    ///   - maxResults: The maximum number of results to include in the response. If more results exist than the specified MaxResults value, a token is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMicrosoftTeamsUserIdentitiesPaginator(
        chatConfigurationArn: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMicrosoftTeamsUserIdentitiesRequest, ListMicrosoftTeamsUserIdentitiesResult> {
        let input = ListMicrosoftTeamsUserIdentitiesRequest(
            chatConfigurationArn: chatConfigurationArn, 
            maxResults: maxResults
        )
        return self.listMicrosoftTeamsUserIdentitiesPaginator(input, logger: logger)
    }
}

extension Chatbot.DescribeChimeWebhookConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.DescribeChimeWebhookConfigurationsRequest {
        return .init(
            chatConfigurationArn: self.chatConfigurationArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chatbot.DescribeSlackChannelConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.DescribeSlackChannelConfigurationsRequest {
        return .init(
            chatConfigurationArn: self.chatConfigurationArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chatbot.DescribeSlackUserIdentitiesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.DescribeSlackUserIdentitiesRequest {
        return .init(
            chatConfigurationArn: self.chatConfigurationArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chatbot.DescribeSlackWorkspacesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.DescribeSlackWorkspacesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chatbot.ListAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.ListAssociationsRequest {
        return .init(
            chatConfiguration: self.chatConfiguration,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chatbot.ListCustomActionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.ListCustomActionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chatbot.ListMicrosoftTeamsConfiguredTeamsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.ListMicrosoftTeamsConfiguredTeamsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chatbot.ListMicrosoftTeamsUserIdentitiesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.ListMicrosoftTeamsUserIdentitiesRequest {
        return .init(
            chatConfigurationArn: self.chatConfigurationArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chatbot.ListTeamsChannelConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chatbot.ListTeamsChannelConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            teamId: self.teamId
        )
    }
}
